/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package ejb.registrazione;

import applicationexcepcion.AccountRegistratoException;
import applicationexcepcion.AddettoNegozioException;
import applicationexcepcion.AmministratoreExeption;
import applicationexcepcion.ClienteCodiceFiscaleNullException;
import applicationexcepcion.ClienteNonValidoException;
import applicationexcepcion.ClienteNullException;
import applicationexcepcion.MarchioRegistratoException;
import applicationexcepcion.NegozioException;
import applicationexcepcion.PersonaRegistrataException;
import applicationexcepcion.ProdottoException;
import applicationexcepcion.RepartoRegistratoException;
import common.Stato;
import ejb.common.AccountManagerLocal;
import ejb.common.AddettoManagerLocal;
import ejb.common.ClienteManagerLocal;
import ejb.common.FotoManagerLocal;
import ejb.common.MarchioManagerLocal;
import ejb.common.NegozioManagerLocal;
import ejb.common.PersonaManagerLocal;
import ejb.common.ProdottoManagerLocal;
import ejb.common.RepartoManagerLocal;
import ejb.common.TripleDESLocal;
import entity.Account;
import entity.AddettoNegozio;
import entity.Amministratore;
import entity.Cliente;
import entity.Comune;
import entity.Foto;
import entity.Marchio;
import entity.Negozio;
import entity.Prodotto;
import entity.Reparto;
import facade.AmministratoreFacade;
import java.sql.Date;
import java.util.GregorianCalendar;
import java.util.List;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.ejb.EJB;
import javax.ejb.Stateless;
import javax.ejb.TransactionAttribute;
import javax.ejb.TransactionAttributeType;
import javax.ejb.TransactionManagement;
import javax.ejb.TransactionManagementType;
import messagediven.EmailManagerLocal;

/**
 *
 * @author Carmela
 */
@Stateless
@TransactionManagement(TransactionManagementType.CONTAINER)
public class Registrazione implements RegistrazioneLocal {
    @EJB
    private EmailManagerLocal emailManager;
    @EJB
    private PersonaManagerLocal personaManager;
    @EJB
    private AmministratoreFacade amministratoreFacade;
    @EJB
    private AddettoManagerLocal addettoManager;
    
    @EJB
    private NegozioManagerLocal negozioManager;

    @EJB
    private ProdottoManagerLocal prodottoManager;
    @EJB
    private RepartoManagerLocal repartoManager;
    @EJB
    private MarchioManagerLocal marchioManager;
    @EJB
    private FotoManagerLocal fotoManager;
    @EJB
    private AccountManagerLocal accountManager;
    @EJB
    private TripleDESLocal tripleDES;
    @EJB
    private ClienteManagerLocal clienteManager;

    /**
     * Questo metodo crea il cliente e l'account e li passa al cliente manager
     *
     * @param nome
     * @param cognome
     * @param codiceFiscale
     * @param dataNascita
     * @param numTelefono
     * @param comune
     * @param via
     * @param username
     * @param password
     * @throws PersonaRegistrataException
     * @throws ClienteNullException
     * @throws ClienteCodiceFiscaleNullException
     * @throws ClienteNonValidoException
     * @throws AccountRegistratoException
     */
    @Override
    @TransactionAttribute(TransactionAttributeType.REQUIRED)
    public void registraCliente(String nome, String cognome, String codiceFiscale,
            Date dataNascita, String numTelefono, Comune comune, String via, String email, String password) throws PersonaRegistrataException, ClienteNullException,
            ClienteCodiceFiscaleNullException, ClienteNonValidoException, AccountRegistratoException {
        Cliente c = new Cliente();
        c.setNome(nome);
        c.setCognome(cognome);
        c.setCodiceFiscale(codiceFiscale);
        c.setComune(comune);
        c.setNumeroDiTelefono(numTelefono);
        c.setDataDiNascita(dataNascita);
        c.setVia(via);
        Account a = new Account();
        a.setEmail(email);
        try {
            a.setPassword(tripleDES.encrypt(password));
        } catch (Exception ex) {
            Logger.getLogger(Registrazione.class.getName()).log(Level.SEVERE, null, ex);
            return;
        }
        a.setDataRegistrazione(new Date(new GregorianCalendar().getTimeInMillis()));
        a.setStato(Stato.Attivo);
        if (accountManager.isRegistrato(a)) {
            throw new AccountRegistratoException();
        }
        if(personaManager.isPersonaRegistrata(codiceFiscale)){
            throw new PersonaRegistrataException();
        }
        accountManager.creaAccount(a);
        c.setAccount(a);
        clienteManager.creaCliente(c);
    }

    @Override
    @TransactionAttribute(TransactionAttributeType.REQUIRED)
    public void registrazioneMarchio(String nomeMarchio, byte[] foto, String fotoNome) throws MarchioRegistratoException {
        Marchio m = marchioManager.cercaPerNome(nomeMarchio);
        if (m != null) {
            throw new MarchioRegistratoException();
        }
        m = new Marchio();
        Foto f = new Foto();
        f.setNome(fotoNome);
        f.setFoto(foto);
        fotoManager.creaFoto(f);
        m.setNome(nomeMarchio);
        m.setFoto(f);
        marchioManager.creaMarchio(m);
    }

    @Override
    @TransactionAttribute(TransactionAttributeType.REQUIRED)
    public void registrazioneReparto(String nomeReparto) throws RepartoRegistratoException {
        Reparto r = repartoManager.cercaPerNome(nomeReparto);
        if (r != null) {
            throw new RepartoRegistratoException();
        }
        r = new Reparto();
        r.setNome(nomeReparto);
        repartoManager.creaReparto(r);
    }

    @Override
    @TransactionAttribute(TransactionAttributeType.REQUIRED)
    public void registrazioneProdotto(Long codiceBarre, String nome, String descrizione, Marchio marchio, Foto f, Reparto reparto) throws ProdottoException {
        Prodotto p = prodottoManager.cercaPerId(codiceBarre);
        if (p != null) {
            throw new ProdottoException("Prodotto gia' esistente");
        }
        if(!prodottoManager.cercaPerNome(nome).isEmpty()){
            throw new ProdottoException("Prodotto già esistente");
        }
        p = new Prodotto();
        p.setCodiceBarre(codiceBarre);
        p.setNome(nome);
        p.setDescrizione(descrizione);
        p.setMarchio(marchio);
        p.setReparto(reparto);
        p.setFoto(f);
        prodottoManager.creaProdotto(p);
    }

    @Override
    @TransactionAttribute(TransactionAttributeType.REQUIRED)
    public void registrazioneNegozio(Negozio negozio) throws NegozioException {
        List<Negozio> l=negozioManager.cercaNegozio(negozio.getNome());
        if(!l.isEmpty()){
            throw new NegozioException();
        }
        negozioManager.creaNegozio(negozio);
    }

    @Override
    @TransactionAttribute(TransactionAttributeType.REQUIRED)
    public void registraAddettoNegozio(AddettoNegozio addettoNegozio) throws AddettoNegozioException {
        if(accountManager.isRegistrato(addettoNegozio.getAccount())){
           throw new AddettoNegozioException();
        }else if(personaManager.isPersonaRegistrata(addettoNegozio.getCodiceFiscale())){
            throw new AddettoNegozioException();
        }else{
            String pass=addettoNegozio.getAccount().getPassword();
            try {
                addettoNegozio.getAccount().setPassword(tripleDES.encrypt(pass));
            } catch (Exception ex) {
                Logger.getLogger(Registrazione.class.getName()).log(Level.SEVERE, null, ex);
                return;
            }
           accountManager.creaAccount(addettoNegozio.getAccount());
           addettoManager.creaAddetto(addettoNegozio);
        }
    }

    @Override
    @TransactionAttribute(TransactionAttributeType.REQUIRED)
    public void registraAmministratore(Amministratore amministratore) throws AmministratoreExeption {
        if(accountManager.isRegistrato(amministratore.getAccount())){
           throw new AmministratoreExeption();
        }else if(personaManager.isPersonaRegistrata(amministratore.getCodiceFiscale())){
            throw new AmministratoreExeption();
        }else{
            String pass=amministratore.getAccount().getPassword();
            try {
                amministratore.getAccount().setPassword(tripleDES.encrypt(pass));
            } catch (Exception ex) {
                Logger.getLogger(Registrazione.class.getName()).log(Level.SEVERE, null, ex);
                return;
            }
           accountManager.creaAccount(amministratore.getAccount());
           amministratoreFacade.create(amministratore);
           emailManager.inviaEmailReimpostaPassword(amministratore);
        }
    }
}
